import { Controller } from 'egg';
import {Op} from 'sequelize'
export default class  ServiceController extends Controller {
    
    //服务支持列表接口
    /**
     * @api {get} /manage/service_list 服务支持列表
     * @apiName manageServiceList
     * @apiGroup Service
     * @apiVersion 1.0.0
     * @apiDescription 服务支持列表
     * @apiParam {String} keyword  关键字查询
     * @apiParam {Number} page  页面位置
     * @apiParam {Number} page_size  页面尺寸
     * @apiParam {Number} type  服务类型 1培训服务 2课程开发 3技能鉴定
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 返回结果
     * @apiSuccess {Object} data.data_info 服务支持列表
     * @apiSuccess {Number} data.data_info.service_id 服务支持ID
     * @apiSuccess {String} data.data_info.service_name 服务支持名称
     * @apiSuccess {String} data.data_info.service_icon  服务支持头像图标路径
     * @apiSuccess {String} data.data_info.create_time 创建时间
     * 
     */
    async list(){
        const {ctx}=this;
        const {query}=ctx.request;
        let condition={};
        try {
            if(query.keyword){
                let keyword=query.keyword;
                condition['service_name']={[Op.like]: '%'+ keyword +'%'};
            }
            let order_condition=[
                ['create_time', 'DESC']
            ];
            //ctx.helper.sort_order(order_condition);
            ctx.body=await ctx.service.common.find_and_count_all(condition,order_condition,query,'Service');
        } catch (error) {
            ctx.body=ctx.helper.error_result("查询异常");
        }

    }
    //服务支持
    /**
     * @api {get} /manage/service_info 服务支持详情
     * @apiName manageServiceInfo
     * @apiGroup Service
     * @apiVersion 1.0.0
     * @apiDescription 服务支持详情
     * @apiParam {Number} service_id  服务支持ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 查询结果结构
     * @apiSuccess {String} data.service_name 服务支持名称
     * @apiSuccess {String} data.service_id 服务支持ID
     * @apiSuccess {String} data.service_icon  服务支持头像图标路径
     * @apiSuccess {Object[]} data.resource_list 服务支持资源列表
     * @apiSuccess {String} data.resource_list.resource_id 资源ID
     * @apiSuccess {String} data.resource_list.resource_name 资源名称
     * @apiSuccess {String} data.resource_list.resource_url 资源路径
     * @apiSuccess {String} data.resource_list.resource_content 资源内容
     * @apiSuccess {String} data.create_time 服务支持创建时间
     * 
     */
    async info(){
        const {ctx,app}= this;
        const {query} = ctx.request;
        const {Service,Resource} = app.model;
        try {
            if(!query.service_id){
                return ctx.body=ctx.helper.error_result("没有指定服务支持ID")
            }
            let condition={
                service_id:query.service_id
            };
            
            let result=await Service.findAll({
                where:condition,
                include:[{
                    model:Resource,
                    association:Service.hasMany(Resource,{foreignKey:"parent_id"}),
                    where:{
                        type:3
                    },
                    required:false
                }]
            })
            let list:object[]=[];
            result=JSON.parse(JSON.stringify(result));
            result.forEach(ele=>{
                console.log(ele);
                ele['create_time']=ctx.helper.date_format_basic(ele['create_time']);
                let service=ctx.helper.assign_basic({},ele);
                service['resource_list']=[];
                if(ele['Resources']&&ele['Resources'].length>0){
                    ele['Resources'].map(resource=>{
                        resource['create_time']=ctx.helper.date_format_basic(resource['create_time']);
                        service['resource_list'].push(resource);
                    })
                }
                
                list.push(service);
            })
            return ctx.body=ctx.helper.success_result("查询成功",list) ;
        } catch (error) {
            
        }
        ctx.body=ctx.helper.error_result("查询失败")
    }
    //服务支持修改
    /**
     * @api {get} /manage/service_update 服务支持修改
     * @apiName manageServiceUpdate
     * @apiGroup Service
     * @apiVersion 1.0.0
     * @apiDescription 服务支持修改
     * @apiParam {Number} service_id  服务支持ID
     * @apiParam {String} service_name 服务支持名称
     * @apiParam {file} service_icon 服务支持图标
     * @apiParam {Object[]} resource  资源对象 
     * @apiParam {String} resource.resource_content 描述文本字符串，可为空
     * @apiParam {String} resource.resource_name  文本标题
     * @apiParam {String} resource.resource_url  资源路径
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * 
     */
    async update(){
        const {ctx,app} = this;
        let {body}=ctx.request;
        let {Service,Resource}=app.model;
        if(!body.service_id){
            return ctx.body=ctx.helper.error_result("没有指定需要修改的服务支持ID")
        }
        let update_obj=ctx.helper.assign_basic({},body);
        try {
            let service:any=await Service.findByPk(body.service_id);
            if(!service||!service['service_id']){
                return ctx.body=ctx.helper.error_result("未找到该服务支持");
            }
            
            let result=await Service.update({...update_obj},{where:{service_id:body.service_id}});
            if(result){
                if(service['service_icon']){
                    ctx.service.common.un_link_file(service['service_icon'])
                }
                if(body.resource&&body.resource.length>0){
                    let del_obj:any=await Resource.destroy({where:{parent_id:body.service_id,type:3}});
                    if(del_obj.length>0){
                        let resources=body.resource;
                        if(resources&&resources.length>0){
                            resources.forEach(element => {
                                element['type']=3;
                                element['parent_id']=body.service_id;
                            });
                            await app.model.Resource.bulkCreate(resources);
                        }
                    }
                }
                return ctx.body=ctx.helper.success_result("修改服务支持成功");
            }
        } catch (error) {
        }
        ctx.body=ctx.helper.error_result("修改服务支持失败");
    }
    
    //删除服务支持
    /**
     * @api {get} /manage/service_del 服务支持删除
     * @apiName manageServiceDel
     * @apiGroup Service
     * @apiVersion 1.0.0
     * @apiDescription 服务支持删除
     * @apiParam {Number} service_id  服务支持ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * 
     */
    async del(){
        const {ctx,app} = this;
        let {body}=ctx.request;
        let {Service,Resource}=app.model;
        if(!body.service_id){
            return ctx.body=ctx.helper.error_result("没有指定需要修改的服务支持ID")
        } 
        try {
            let service:any=await Service.findByPk(body.service_id);
            if(!service||!service['service_id']){
                return ctx.body=ctx.helper.error_result("未找到该服务支持");
            }
            let result=await Service.destroy({where:{service_id:body.service_id}});
            if(result){
                if(service['service_icon']){
                    ctx.service.common.un_link_file(service['service_icon'])
                }
                if(body.resource&&body.resource.length>0){
                    let del_obj:any=await Resource.destroy({where:{parent_id:body.service_id,type:3}});
                    if(del_obj.length>0){
                        let resources=body.resource;
                        if(resources&&resources.length>0){
                            resources.forEach(element => {
                                element['type']=3;
                                element['parent_id']=body.service_id;
                            });
                            await app.model.Resource.bulkCreate(resources);
                        }
                    }
                }
                return ctx.body=ctx.helper.success_result("删除成功");
            }else{
                return ctx.body=ctx.helper.success_result("未删除数据");
            }
        } catch (error) {
            console.log(error);
        }
        ctx.body=ctx.helper.error_result("删除服务支持失败")
    }
    //服务支持新增
    /**
     * @api {get} /manage/service_add 服务支持新增
     * @apiName manageServiceAdd
     * @apiGroup Service
     * @apiVersion 1.0.0
     * @apiDescription 服务支持新增
     * @apiParam {String} service_name 服务支持名称
     * @apiParam {String} service_icon 服务支持图标
     * @apiParam {Object[]} resource  资源对象 
     * @apiParam {String} resource.resource_content 描述文本字符串，可为空
     * @apiParam {String} resource.resource_name  文本标题
     * @apiParam {String} resource.resource_url  资源路径
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * 
     */
    async add(){
        const {ctx,app}=this;
        const {body}=ctx.request
        if(!body.service_name){
            return ctx.body=ctx.helper.error_result("必须指定服务支持名称");
        }
        let service={
            service_name:body.service_name,
            service_icon:body.service_icon
        }
        try {
            let result=await app.model.Service.create(service);
            if(result&&result['service_id']){
                let service_id=result['service_id'];
                let resources=body.resource;
                if(resources&&resources.length>0){
                    resources.forEach(element => {
                        element['type']=3;
                        element['parent_id']=service_id;
                    });
                    await app.model.Resource.bulkCreate(resources);
                }
                ctx.body=ctx.helper.success_result("添加服务成功");
                return ctx.body=ctx.helper.success_result("操作成功");
            }  
        } catch(error){
            
        }finally{
          await ctx.cleanupRequestFiles();
        }
        ctx.body=ctx.helper.error_result("添加失败")
    }

   
}

